home *** CD-ROM | disk | FTP | other *** search
/ CD Classic 39 / CD CLASSIC #39 (1998).iso / EMPRESA / visio / Vistdstd / Install / Data.Z / Vaddon.CPP < prev    next >
C/C++ Source or Header  |  1997-11-11  |  9KB  |  421 lines
  1. /*    VADDON.CPP - Source for Visio VSL Entry Point
  2.  *  Copyright (C) 1996-1997 Visio Corporation. All rights reserved.
  3.  *
  4.  *    Abstract
  5.  *        Provides the entry point for a Visio VSL.
  6.  *        Also provides an addon 'manager' superclass;
  7.  *        derive classes from VAddon and we'll take
  8.  *        care of the rest!
  9.  *
  10.  *    Routines:
  11.  *        VisioLibMain    Entry point that Visio calls.
  12.  *        VAddon::FindAddon
  13.  *        VAddon::GetFirst
  14.  *        VAddon::GetNext
  15.  *        Default implementations of all VAddon methods but Run.
  16.  */
  17.  
  18. //    Important NOTE:
  19. //    If you build this source file into an EXE (rather than a VSL/DLL)
  20. //    then be sure to #define VADDON_EXE on the compiler command line.
  21.  
  22. //    If you're using MFC, be sure VADDON_MFC gets defined.
  23. //    _USRDLL is the criterion we're using to "decide" if you're
  24. //    using MFC -- if you're using it, but don't have _USRDLL defined
  25. //    then define VADDON_MFC on the command line.
  26.  
  27. #ifdef _USRDLL
  28. #define VADDON_MFC
  29. #endif
  30.  
  31. #ifdef VADDON_MFC
  32. #include "stdafx.h"
  33. #endif
  34.  
  35. #include "vaddon.h"
  36.  
  37.  
  38.  
  39. //    Only compile in the exported entry point VisioLibMain
  40. //    if NOT being built into an EXE:
  41.  
  42. #ifndef VADDON_EXE
  43.  
  44. extern "C" {
  45.  
  46. VAOEXPORT VAORC VAOCB VisioLibMain(VAOMSG wMsg, WORD wParam, LPVOID lpParam)
  47.     {
  48.     VAORC result;
  49.  
  50. #ifdef VADDON_MFC
  51.     AFX_MANAGE_STATE(AfxGetStaticModuleState());
  52. #endif
  53.  
  54.     result= VAORC_SUCCESS;
  55.  
  56.     switch (wMsg)
  57.         {
  58.         case V2LMSG_ENUMADDONS:
  59.             {
  60.             VAddon *pAddon= VAddon::GetFirst();
  61.  
  62.             while (NULL!=pAddon && VAORC_SUCCESS==result)
  63.                 {
  64.                 result= VAOUtil_RegisterAddons(
  65.                                 ((LPVAOV2LSTRUCT)lpParam)->wSessID,
  66.                                 pAddon->GetRegStructPtr(),
  67.                                 1);
  68.  
  69.                 pAddon= VAddon::GetNext(pAddon);
  70.                 }
  71.  
  72.             break;
  73.             }
  74.  
  75.         case V2LMSG_ISAOENABLED:
  76.             {
  77.             VAddon *pAddon= VAddon::FindAddon(wParam);
  78.  
  79.             if (pAddon)
  80.                 result= pAddon->IsEnabled((LPVAOV2LSTRUCT)lpParam);
  81.  
  82.             break;
  83.             }
  84.  
  85.         case V2LMSG_RUN:
  86.             {
  87.             VAddon *pAddon= VAddon::FindAddon(wParam);
  88.  
  89.             if (pAddon)
  90.                 result= pAddon->Run((LPVAOV2LSTRUCT)lpParam);
  91.  
  92.             break;
  93.             }
  94.  
  95.         case V2LMSG_RUNABOUT:
  96.             {
  97.             VAddon *pAddon= VAddon::FindAddon(wParam);
  98.  
  99.             if (pAddon)
  100.                 result= pAddon->About((LPVAOV2LSTRUCT)lpParam);
  101.  
  102.             break;
  103.             }
  104.  
  105.         case V2LMSG_RUNHELP:
  106.             {
  107.             VAddon *pAddon= VAddon::FindAddon(wParam);
  108.  
  109.             if (pAddon)
  110.                 result= pAddon->Help((LPVAOV2LSTRUCT)lpParam);
  111.  
  112.             break;
  113.             }
  114.  
  115.         case V2LMSG_LOAD:
  116.             {
  117.             VAddon *pAddon= VAddon::GetFirst();
  118.  
  119.             result= VAO_L2V_VERSION();
  120.  
  121.             while (NULL!=pAddon && VAO_L2V_VERSION()==result)
  122.                 {
  123.                 result= pAddon->Load(wParam, lpParam);
  124.  
  125.                 pAddon= VAddon::GetNext(pAddon);
  126.                 }
  127.  
  128.             break;
  129.             }
  130.  
  131.         case V2LMSG_UNLOAD:
  132.             {
  133.             VAddon *pAddon= VAddon::GetFirst();
  134.  
  135.             while (NULL!=pAddon && VAORC_SUCCESS==result)
  136.                 {
  137.                 result= pAddon->Unload(wParam, lpParam);
  138.  
  139.                 pAddon= VAddon::GetNext(pAddon);
  140.                 }
  141.  
  142.             break;
  143.             }
  144.  
  145.         case V2LMSG_KILLSESSION:
  146.             {
  147.             //    Since we don't know which VAddon instance is being
  148.             //    told to kill its session, because wParam is 0 for
  149.             //    V2LMSG_KILLSESSION, loop through all instances to
  150.             //    give each one a chance to clean up after itself.
  151.             //
  152.             //    (A VAddon subclass would "know" if it were in a session
  153.             //     or not by remembering the wSessID from the Run method
  154.             //     in which it returned VAORC_L2V_MODELESS to Visio.)
  155.  
  156.             VAddon *pAddon= VAddon::GetFirst();
  157.  
  158.             while (NULL!=pAddon)
  159.                 {
  160.                 pAddon->KillSession((LPVAOV2LSTRUCT)lpParam);
  161.  
  162.                 pAddon= VAddon::GetNext(pAddon);
  163.                 }
  164.  
  165.             //    result= VAORC_SUCCESS...
  166.             //    ...already assigned before entering switch statement
  167.  
  168.             break;
  169.             }
  170.  
  171.         default:
  172.             {
  173.             result= VAOUtil_DefVisMainProc(wMsg, wParam, lpParam, VLIBUTL_hModule());
  174.             break;
  175.             }
  176.         }
  177.  
  178.     return result;
  179.     }
  180.  
  181. }    //    end extern "C"
  182.  
  183. #endif    //    VADDON_EXE
  184.  
  185.  
  186. //****************************************************************************
  187. //
  188. //    Class VAddon implementation:
  189. //
  190.  
  191. VAddon *VAddon::m_pFirst= NULL;
  192. VAddon *VAddon::m_pLast= NULL;
  193. WORD VAddon::m_wNextIndex= 1;
  194. HINSTANCE VAddon::m_hInstance= NULL;
  195.  
  196.  
  197.  
  198. VAddon::VAddon(
  199.         //    VAO_ORDINAL assigned automagically by this base class...
  200.         VAO_ATTS atts,                // Attributes
  201.         VAO_ENABMASK enabMask,        // Enabling policy
  202.         VAO_INVOKEMASK invokeOnMask,
  203.         VAO_NOTIFYMASK notifyOnMask,
  204.         LPCTSTR lpName,
  205.         UINT uIDName /* = INVALID_RESOURCE_ID */)
  206. {
  207.     //    Initialize beginning of linked list:
  208.     if (NULL==m_pFirst)
  209.         m_pFirst= this;
  210.  
  211.     //    Tack onto end of linked list:
  212.     if (NULL!=m_pLast)
  213.         m_pLast->m_pNext= this;
  214.  
  215.     m_pLast= this;
  216.     m_pNext= NULL;
  217.  
  218.     //    Assign ordinal:
  219.     m_wIndex= m_wNextIndex;
  220.     m_wNextIndex++;
  221.  
  222.     //    Setup name:
  223.     m_pName[0]= (TCHAR) 0;
  224.     if (NULL!=lpName)
  225.     {
  226.         _tcsncpy(m_pName, lpName, sizeof(m_pName)-1);
  227.         m_pName[sizeof(m_pName)-1]= (TCHAR) 0;
  228.     }
  229.  
  230. #ifdef _DEBUG
  231.     //    Append to the DEBUG version so it shows up differently in Visio's UI:
  232.     if ( _tcslen(m_pName) < (VAOMAXAONAME - _tcslen(_T(" - DEBUG")) - 1) )
  233.     {
  234.         _tcscat(m_pName, _T(" - DEBUG"));
  235.     }
  236. #endif
  237.  
  238.     //    Fill in reg struct:
  239.     m_reg.ord= m_wIndex;
  240.     m_reg.atts= atts;
  241.     m_reg.enabMask= enabMask;
  242.     m_reg.invokeOnMask= invokeOnMask;
  243.     m_reg.notifyOnMask= notifyOnMask;
  244.     m_reg.lpName= (LPCTSTR) m_pName;
  245.  
  246.     //    If this is not INVALID_RESOURCE_ID, then we'll attempt a
  247.     //    LoadString in the "Load" method to replace the name with:
  248.     m_uIDName= uIDName;
  249. }
  250.  
  251. VAddon::~VAddon()
  252. {
  253.  
  254. }
  255.  
  256. VAOREGSTRUCT *VAddon::GetRegStructPtr(void)
  257. {
  258.     return &m_reg;
  259. }
  260.  
  261. /* static */ VAddon *VAddon::FindAddon(WORD wOrdinal)
  262. {
  263.     //    returns VAddon with m_wIndex==wOrdinal, or NULL if not in list...
  264.     VAddon *pFound= GetFirst();
  265.  
  266.     while (pFound!=NULL && pFound->m_wIndex!=wOrdinal)
  267.     {
  268.         pFound= GetNext(pFound);
  269.     }
  270.  
  271.     return pFound;
  272. }
  273.  
  274. /* static */ VAddon *VAddon::GetFirst(void)
  275. {
  276.     return m_pFirst;
  277. }
  278.  
  279. /* static */ VAddon *VAddon::GetNext(VAddon *pCurrent)
  280. {
  281.     //    returns NULL when no more...
  282.  
  283.     if (pCurrent)
  284.         return pCurrent->m_pNext;
  285.  
  286.     return NULL;
  287. }
  288.  
  289. /* static */ void VAddon::SetInstance(HINSTANCE hInstance)
  290. {
  291.     //    Call this once from WinMain or InitInstance:
  292.     m_hInstance= hInstance;
  293. }
  294.  
  295. HINSTANCE VAddon::GetInstance(long nFlags /*= 0L*/)
  296. {
  297.     //    If you DON'T use MFC
  298.     //        AND
  299.     //    you've written your own DllMain or WinMain,
  300.     //    forsaking all our example code, then....
  301.  
  302.     //    ...You should override this function in your
  303.     //    add-ons to provide an HINSTANCE to your
  304.     //    DLL or EXE.
  305.  
  306.     UNUSED_ARG(nFlags);
  307.  
  308. #ifdef VADDON_MFC
  309.  
  310.     //    Use MFC's built-in function.
  311.     return AfxGetInstanceHandle();
  312.  
  313. #else
  314.  
  315.     //    Return private data set by our own
  316.     //    DllMain or WinMain...
  317.  
  318.     #ifdef VADDON_EXE
  319.         return m_hInstance;
  320.     #else
  321.         return VLIBUTL_hModule();
  322.     #endif
  323.  
  324. #endif
  325. }
  326.  
  327.  
  328. //****************************************************************************
  329. //
  330. //    Messages we have to respond to:
  331. //
  332.  
  333. VAORC VAddon::IsEnabled(LPVAOV2LSTRUCT pV2L)
  334. {
  335.     UNUSED_ARG(pV2L);
  336.     return VAORC_L2V_ENABLED;
  337. }
  338.  
  339. //    No implementation at this abstract level...
  340. //    MUST be overridden
  341. //VAORC VAddon::Run(LPVAOV2LSTRUCT pV2L)
  342. //{
  343. //    return VAORC_SUCCESS;
  344. //}
  345.  
  346. VAORC VAddon::About(LPVAOV2LSTRUCT pV2L)
  347. {
  348.     //    No-op at this abstract level...
  349.     UNUSED_ARG(pV2L);
  350.     return VAORC_SUCCESS;
  351. }
  352.  
  353. VAORC VAddon::Help(LPVAOV2LSTRUCT pV2L)
  354. {
  355.     //    No-op at this abstract level...
  356.     UNUSED_ARG(pV2L);
  357.     return VAORC_SUCCESS;
  358. }
  359.  
  360. VAORC VAddon::Load(WORD wVersion, LPVOID p)
  361. {
  362.     TCHAR szName[VAOMAXAONAME]= _T("");
  363.  
  364.     //    If m_uIDName is not INVALID_RESOURCE_ID, then replace
  365.     //    m_pName with the result of a successful LoadString:
  366.  
  367.     if (INVALID_RESOURCE_ID!=m_uIDName)
  368.     {
  369.         if (0!=LoadString(GetInstance(), m_uIDName, &szName[0], sizeof(szName)-1))
  370.         {
  371.             //    Because the REGSTRUCT m_reg name field already points to
  372.             //    our m_pName buffer, there's nothing more we have to do.
  373.             //    The V2LMSG_ENUMADDONS call will come next and we will
  374.             //    be registered with this resource loaded name:
  375.  
  376.             _tcscpy(m_pName, szName);
  377.  
  378. #ifdef _DEBUG
  379.             //    Append to the DEBUG version so it shows up differently in Visio's UI:
  380.             if ( _tcslen(m_pName) < (VAOMAXAONAME - _tcslen(_T(" - DEBUG")) - 1) )
  381.             {
  382.                 _tcscat(m_pName, _T(" - DEBUG"));
  383.             }
  384. #endif
  385.         }
  386.     }
  387.  
  388. #ifdef VADDON_EXE
  389.     //    Executable target:
  390.     return VAO_L2V_VERSION();    //    special return value for 'Load'...
  391. #else
  392.     //    VSL target:
  393.     //    Default common load behavior:
  394.     return VAOUtil_DefVisMainProc(V2LMSG_LOAD, wVersion, p, GetInstance());
  395. #endif
  396. }
  397.  
  398. VAORC VAddon::Unload(WORD wParam, LPVOID p)
  399. {
  400. #ifdef VADDON_EXE
  401.     //    Executable target:
  402.     return VAORC_SUCCESS;
  403. #else
  404.     //    VSL target:
  405.     //    Default common unload behavior:
  406.     return VAOUtil_DefVisMainProc(V2LMSG_UNLOAD, wParam, p, GetInstance());
  407. #endif
  408. }
  409.  
  410. VAORC VAddon::KillSession(LPVAOV2LSTRUCT pV2L)
  411. {
  412. #ifdef VADDON_EXE
  413.     //    Executable target:
  414.     return VAORC_SUCCESS;
  415. #else
  416.     //    VSL target:
  417.     //    Default common kill session behavior:
  418.     return VAOUtil_DefVisMainProc(V2LMSG_KILLSESSION, GetIndex(), pV2L, GetInstance());
  419. #endif
  420. }
  421.